package com.blankii.androidlibrary.utils

object CalcUtil {

    //16进制字符串转byte数组
    fun Hex2Byte(inHex: String): ByteArray {
        val hex = inHex.split(" ".toRegex()).toTypedArray() //将接收的字符串按空格分割成数组
        val byteArray = ByteArray(hex.size)
        for (i in hex.indices) {
            //parseInt()方法用于将字符串参数作为有符号的n进制整数进行解析
            byteArray[i] = hex[i].toInt(16).toByte()
        }
        return byteArray
    }

    /**
     * int 转带空格的十六进制 负数
     * tag=false -1->FFFF  1->0001
     * @param i Int 待转的int 值
     * @param bytes Int 要求输出的十六进制字节数默认两个字节  00 01
     * @return String
     */
    fun Int2SpaceHex(i: Int, tag: Boolean, bytes: Int = 2): String {
        var hex = ""
        hex = if (tag) {
            Integer.toHexString(i)
        } else {
            Integer.toHexString(i and 0xFFFF)
        }
        if (hex.length % 2 == 1) {//数据个数如果是奇数 1->01
            hex = "0".plus(hex)
        }
        while (bytes > hex.length / 2) { //要求输出2个字节0001 但是现在01 则01->0001
            hex = "00".plus(hex)
        }
        val charArray = hex.toCharArray()
        hex = ""
        for (i in charArray.indices) {//0001->00 01
            hex += charArray[i]
            if (i % 2 == 1) {
                hex += " "
            }
        }
        return hex.trimEnd()
    }


    //byte数组转16进制字符串
    fun Byte2Hex(inByte: ByteArray): String {
        val sb = StringBuilder()
        for (b in inByte) {
            sb.append(String.format("%02x", b) + " ")
        }
        return sb.toString().uppercase()
    }

    /**
     * 处理带不带空格都行的十六进制转Int
     * tag=true FFFF=-1    tag=false FFFF=65535
     * @param hex String
     * @return Int
     */
    fun Hex2IntStr(hex: String, tag: Boolean = false): String {
        val stringBuilder = StringBuilder()
        var array: Array<String>? = null
        if (hex.contains(" ")) {
            array = hex.split(" ").toTypedArray()
        } else if (hex.contains("\t")) {
            array = hex.split("\t").toTypedArray()
        } else {
            return if (tag) {
                hex.toInt(16).toShort().toString()
            } else {
                hex.toInt(16).toString()
            }

        }
        array!!.forEach {
            stringBuilder.append(it)
        }
        return if (tag) {
            stringBuilder.toString().toInt(16).toString()
        } else {
            stringBuilder.toString().toInt(16).toShort().toString()
        }
    }


    //翻转CRC16， 低字节与高字节互换，modbus 要求的
    fun processCRC16(crc16: String): String {
        var crc16 = crc16
        if (crc16.length == 3) {
            crc16 = "0$crc16"
        } else if (crc16.length == 2) {
            crc16 = "00$crc16"
        } else if (crc16.length == 1) {
            crc16 = "000$crc16"
        }
        return crc16.substring(2) + " " + crc16.substring(0, 2)
    }

    fun Hex2BinaryString(hexString: String): String {
        val binaryString = Integer.toBinaryString(Integer.parseInt(hexString, 16))
        /**
         * 不足16位，往高位补零
         */
        return String.format("%" + 16 + "s", binaryString).replace(' ', '0')
    }

    /**
     * 十进制转二进制字符串
     */
    fun Int2BinaryString(i: Int): String {
        val b = Integer.toBinaryString(i)
        return String.format("%" + 16 + "s", b).replace(' ', '0')
    }

    /**
     * 十六进制转ascii字符
     * 一个字节十六进制转一个字符
     */
    fun Hex2CharString(hex: String): String {
        var hexArray = ArrayList<String>()
        if (hex.contains("\t")) {
            hexArray.addAll(hex.split("\t"))
        } else if (hex.contains(" ")) {
            hexArray.addAll(hex.split(" "))
        } else {
            for (i in hex.indices) {
                if (2 * i + 2 > hex.length) {
                    break
                }
                hexArray.add(hex.substring(2 * i, 2 * i + 2))
            }
        }

        var result = ""
        hexArray.forEach {
            val c = Integer.parseInt(it, 16).toChar()
            result += c
        }
        return result
    }

//    int n1 = 14;
//    //十进制转成十六进制：
//    System.out.println( Integer.toHexString(n1));
//    //十进制转成八进制
//    System.out.println(Integer.toOctalString(n1));
//    //十进制转成二进制
//    System.out.println(Integer.toBinaryString(12));
//
//    //十六进制转成十进制
//    System.out.println(Integer.valueOf("FFFF", 16).toString());
//    //十六进制转成二进制
//    System.out.println(Integer.toBinaryString(Integer.parseInt("FFFF", 16)));
//    //十六进制转成八进制
//    System.out.println(Integer.toOctalString(Integer.valueOf("FFFF", 16)));
//
//    //八进制转成十进制
//    System.out.println(Integer.valueOf("576", 8).toString());
//    //八进制转成二进制
//    System.out.println(Integer.toBinaryString(Integer.valueOf("23", 8)));
//    //八进制转成十六进制
//    System.out.println(Integer.toHexString(Integer.valueOf("23", 8)));
//
//
//    //二进制转十进制
//    System.out.println(Integer.valueOf("0101", 2).toString());
//    //二进制转八进制
//    System.out.println(Integer.toOctalString(Integer.parseInt("0101", 2)));
//    //二进制转十六进制
//    System.out.println(Integer.toHexString(Integer.parseInt("0101", 2)));

}